using RxjhServer.HelperTools;
using RxjhServer.Network;
using System;

namespace RxjhServer
{
	public class 物品类 : IDisposable
	{
		public bool 锁定;

		private bool _物品绑定;

		private string _物品string;

		private int _物品位置;

		private byte[] _物品_byte;

		private Itimesx _属性1;

		private Itimesx _属性2;

		private Itimesx _属性3;

		private Itimesx _属性4;

		private int _物品防御力;

		private int _物品攻击力;

		private int _物品攻击力MAX;

		private int _物品属性强类型;

		private int _物品属性强;

		private int _物品属性阶段类型;

		private int _物品属性阶段数;

		private int _物品属性_攻击力增加;

		private int _物品属性_防御力增加;

		private int _物品属性_生命力增加;

		private int _物品属性_内功力增加;

		private int _物品属性_命中率增加;

		private int _物品属性_回避率增加;

		private int _物品属性_武功攻击力;

		private int _物品属性_全部气功等级增加;

		private int _物品属性_升级成功率;

		private int _物品属性_追加伤害值;

		private int _物品属性_武功防御力增加;

		private int _物品属性_获得金钱增加;

		private int _物品属性_死亡损失经验减少;

		private int _物品属性_经验获得增加;

		private int _物品属性_追加刀客力劈华山;

		private int _物品属性_追加刀客四两千斤;

		private int _物品属性_追加刀客必杀一击;

		private int _物品属性_追加刀客摄魂一击;

		private int _物品属性_追加刀客暗影绝杀;

		private int _物品属性_追加刀客狂风万破;

		private int _物品属性_追加刀客真武绝击;

		private int _物品属性_追加刀客稳如泰山;

		private int _物品属性_追加刀客连环飞舞;

		private int _物品属性_追加刀客霸气破甲;

		private int _物品属性_追加剑客冲冠一怒;

		private int _物品属性_追加剑客回柳身法;

		private int _物品属性_追加剑客必杀一击;

		private int _物品属性_追加剑客怒海狂澜;

		private int _物品属性_追加剑客护身罡气;

		private int _物品属性_追加剑客狂风万破;

		private int _物品属性_追加剑客百变神行;

		private int _物品属性_追加剑客移花接木;

		private int _物品属性_追加剑客连环飞舞;

		private int _物品属性_追加剑客长虹贯日;

		private int _物品属性_追加医九天真气;

		private int _物品属性_追加医体血倍增;

		private int _物品属性_追加医吸星大法;

		private int _物品属性_追加医天佑之气;

		private int _物品属性_追加医太极心法;

		private int _物品属性_追加医妙手回春;

		private int _物品属性_追加医洗髓易经;

		private int _物品属性_追加医神农仙术;

		private int _物品属性_追加医运气行心;

		private int _物品属性_追加医长功攻击;

		private int _物品属性_追加弓凝神聚气;

		private int _物品属性_追加弓心神凝聚;

		private int _物品属性_追加弓必杀一击;

		private int _物品属性_追加弓无明暗矢;

		private int _物品属性_追加弓正本培元;

		private int _物品属性_追加弓流星三矢;

		private int _物品属性_追加弓狂风万破;

		private int _物品属性_追加弓猎鹰之眼;

		private int _物品属性_追加弓百步穿杨;

		private int _物品属性_追加弓锐利之箭;

		private int _物品属性_追加枪客乾坤挪移;

		private int _物品属性_追加枪客必杀一击;

		private int _物品属性_追加枪客横练太保;

		private int _物品属性_追加枪客灵甲护身;

		private int _物品属性_追加枪客狂神降世;

		private int _物品属性_追加枪客狂风万破;

		private int _物品属性_追加枪客转守为攻;

		private int _物品属性_追加枪客运气疗伤;

		private int _物品属性_追加枪客连环飞舞;

		private int _物品属性_追加枪客金钟罩气;

		private int _FLD_RESIDE2;

		private int _FLD_LEVEL;

		public bool 物品绑定
		{
			get
			{
				try
				{
					byte[] array = new byte[2];
					Buffer.BlockCopy(物品_byte, 36, array, 0, 1);
					if (BitConverter.ToInt16(array, 0) != 0)
					{
						return true;
					}
					return false;
				}
				catch (Exception)
				{
					return false;
				}
			}
			set
			{
				_物品绑定 = value;
			}
		}

		public long Get物品全局ID => BitConverter.ToInt64(物品_byte, 0);

		public long Set物品全局ID
		{
			set
			{
				Buffer.BlockCopy(BitConverter.GetBytes(value), 0, 物品_byte, 0, 8);
			}
		}

		public int Get物品ID => BitConverter.ToInt32(物品_byte, 8);

		public int Get物品数量 => BitConverter.ToInt32(物品_byte, 12);

		public string 物品string
		{
			get
			{
				return 得到物品string();
			}
			set
			{
				_物品string = value;
			}
		}

		public int 物品位置
		{
			get
			{
				return _物品位置;
			}
			set
			{
				_物品位置 = value;
			}
		}

		public int 物品类型 => 得到物品类型();

		public int 物品单个重量 => 得到物品单个重量();

		public int 物品总重量 => 得到物品重量();

		public byte[] 物品_byte
		{
			get
			{
				return _物品_byte;
			}
			set
			{
				锁定 = false;
				_物品_byte = value;
			}
		}

		public byte[] 物品数量
		{
			get
			{
				return 得到物品数量();
			}
			set
			{
				设置物品数量(value);
			}
		}

		public byte[] 物品ID => 得到物品ID();

		public byte[] 物品全局ID => 得到全局ID();

		public byte[] 物品属性 => 得到物品属性();

		public Itimesx 属性1
		{
			get
			{
				byte[] array = new byte[4];
				Buffer.BlockCopy(物品_byte, 20, array, 0, 4);
				属性1 = new Itimesx(array);
				return _属性1;
			}
			set
			{
				_属性1 = value;
			}
		}

		public Itimesx 属性2
		{
			get
			{
				byte[] array = new byte[4];
				Buffer.BlockCopy(物品_byte, 24, array, 0, 4);
				属性2 = new Itimesx(array);
				return _属性2;
			}
			set
			{
				_属性2 = value;
			}
		}

		public Itimesx 属性3
		{
			get
			{
				byte[] array = new byte[4];
				Buffer.BlockCopy(物品_byte, 28, array, 0, 4);
				属性3 = new Itimesx(array);
				return _属性3;
			}
			set
			{
				_属性3 = value;
			}
		}

		public Itimesx 属性4
		{
			get
			{
				byte[] array = new byte[4];
				Buffer.BlockCopy(物品_byte, 32, array, 0, 4);
				属性4 = new Itimesx(array);
				return _属性4;
			}
			set
			{
				_属性4 = value;
			}
		}

		public int 物品防御力
		{
			get
			{
				return _物品防御力;
			}
			set
			{
				_物品防御力 = value;
			}
		}

		public int 物品攻击力
		{
			get
			{
				return _物品攻击力;
			}
			set
			{
				_物品攻击力 = value;
			}
		}

		public int 物品攻击力MAX
		{
			get
			{
				return _物品攻击力MAX;
			}
			set
			{
				_物品攻击力MAX = value;
			}
		}

		public int 物品属性强类型
		{
			get
			{
				return _物品属性强类型;
			}
			set
			{
				_物品属性强类型 = value;
			}
		}

		public int 物品属性强
		{
			get
			{
				return _物品属性强;
			}
			set
			{
				_物品属性强 = value;
			}
		}

		public int 物品属性阶段类型
		{
			get
			{
				return _物品属性阶段类型;
			}
			set
			{
				_物品属性阶段类型 = value;
			}
		}

		public int 物品属性阶段数
		{
			get
			{
				return _物品属性阶段数;
			}
			set
			{
				_物品属性阶段数 = value;
			}
		}

		public int 物品属性_攻击力增加
		{
			get
			{
				return _物品属性_攻击力增加;
			}
			set
			{
				_物品属性_攻击力增加 = value;
			}
		}

		public int 物品属性_防御力增加
		{
			get
			{
				return _物品属性_防御力增加;
			}
			set
			{
				_物品属性_防御力增加 = value;
			}
		}

		public int 物品属性_生命力增加
		{
			get
			{
				return _物品属性_生命力增加;
			}
			set
			{
				_物品属性_生命力增加 = value;
			}
		}

		public int 物品属性_内功力增加
		{
			get
			{
				return _物品属性_内功力增加;
			}
			set
			{
				_物品属性_内功力增加 = value;
			}
		}

		public int 物品属性_命中率增加
		{
			get
			{
				return _物品属性_命中率增加;
			}
			set
			{
				_物品属性_命中率增加 = value;
			}
		}

		public int 物品属性_回避率增加
		{
			get
			{
				return _物品属性_回避率增加;
			}
			set
			{
				_物品属性_回避率增加 = value;
			}
		}

		public int 物品属性_武功攻击力
		{
			get
			{
				return _物品属性_武功攻击力;
			}
			set
			{
				_物品属性_武功攻击力 = value;
			}
		}

		public int 物品属性_全部气功等级增加
		{
			get
			{
				return _物品属性_全部气功等级增加;
			}
			set
			{
				_物品属性_全部气功等级增加 = value;
			}
		}

		public int 物品属性_升级成功率
		{
			get
			{
				return _物品属性_升级成功率;
			}
			set
			{
				_物品属性_升级成功率 = value;
			}
		}

		public int 物品属性_追加伤害值
		{
			get
			{
				return _物品属性_追加伤害值;
			}
			set
			{
				_物品属性_追加伤害值 = value;
			}
		}

		public int 物品属性_武功防御力增加
		{
			get
			{
				return _物品属性_武功防御力增加;
			}
			set
			{
				_物品属性_武功防御力增加 = value;
			}
		}

		public int 物品属性_获得金钱增加
		{
			get
			{
				return _物品属性_获得金钱增加;
			}
			set
			{
				_物品属性_获得金钱增加 = value;
			}
		}

		public int 物品属性_死亡损失经验减少
		{
			get
			{
				return _物品属性_死亡损失经验减少;
			}
			set
			{
				_物品属性_死亡损失经验减少 = value;
			}
		}

		public int 物品属性_经验获得增加
		{
			get
			{
				return _物品属性_经验获得增加;
			}
			set
			{
				_物品属性_经验获得增加 = value;
			}
		}

		public int 物品属性_追加刀客力劈华山
		{
			get
			{
				return _物品属性_追加刀客力劈华山;
			}
			set
			{
				_物品属性_追加刀客力劈华山 = value;
			}
		}

		public int 物品属性_追加刀客四两千斤
		{
			get
			{
				return _物品属性_追加刀客四两千斤;
			}
			set
			{
				_物品属性_追加刀客四两千斤 = value;
			}
		}

		public int 物品属性_追加刀客必杀一击
		{
			get
			{
				return _物品属性_追加刀客必杀一击;
			}
			set
			{
				_物品属性_追加刀客必杀一击 = value;
			}
		}

		public int 物品属性_追加刀客摄魂一击
		{
			get
			{
				return _物品属性_追加刀客摄魂一击;
			}
			set
			{
				_物品属性_追加刀客摄魂一击 = value;
			}
		}

		public int 物品属性_追加刀客暗影绝杀
		{
			get
			{
				return _物品属性_追加刀客暗影绝杀;
			}
			set
			{
				_物品属性_追加刀客暗影绝杀 = value;
			}
		}

		public int 物品属性_追加刀客狂风万破
		{
			get
			{
				return _物品属性_追加刀客狂风万破;
			}
			set
			{
				_物品属性_追加刀客狂风万破 = value;
			}
		}

		public int 物品属性_追加刀客真武绝击
		{
			get
			{
				return _物品属性_追加刀客真武绝击;
			}
			set
			{
				_物品属性_追加刀客真武绝击 = value;
			}
		}

		public int 物品属性_追加刀客稳如泰山
		{
			get
			{
				return _物品属性_追加刀客稳如泰山;
			}
			set
			{
				_物品属性_追加刀客稳如泰山 = value;
			}
		}

		public int 物品属性_追加刀客连环飞舞
		{
			get
			{
				return _物品属性_追加刀客连环飞舞;
			}
			set
			{
				_物品属性_追加刀客连环飞舞 = value;
			}
		}

		public int 物品属性_追加刀客霸气破甲
		{
			get
			{
				return _物品属性_追加刀客霸气破甲;
			}
			set
			{
				_物品属性_追加刀客霸气破甲 = value;
			}
		}

		public int 物品属性_追加剑客冲冠一怒
		{
			get
			{
				return _物品属性_追加剑客冲冠一怒;
			}
			set
			{
				_物品属性_追加剑客冲冠一怒 = value;
			}
		}

		public int 物品属性_追加剑客回柳身法
		{
			get
			{
				return _物品属性_追加剑客回柳身法;
			}
			set
			{
				_物品属性_追加剑客回柳身法 = value;
			}
		}

		public int 物品属性_追加剑客必杀一击
		{
			get
			{
				return _物品属性_追加剑客必杀一击;
			}
			set
			{
				_物品属性_追加剑客必杀一击 = value;
			}
		}

		public int 物品属性_追加剑客怒海狂澜
		{
			get
			{
				return _物品属性_追加剑客怒海狂澜;
			}
			set
			{
				_物品属性_追加剑客怒海狂澜 = value;
			}
		}

		public int 物品属性_追加剑客护身罡气
		{
			get
			{
				return _物品属性_追加剑客护身罡气;
			}
			set
			{
				_物品属性_追加剑客护身罡气 = value;
			}
		}

		public int 物品属性_追加剑客狂风万破
		{
			get
			{
				return _物品属性_追加剑客狂风万破;
			}
			set
			{
				_物品属性_追加剑客狂风万破 = value;
			}
		}

		public int 物品属性_追加剑客百变神行
		{
			get
			{
				return _物品属性_追加剑客百变神行;
			}
			set
			{
				_物品属性_追加剑客百变神行 = value;
			}
		}

		public int 物品属性_追加剑客移花接木
		{
			get
			{
				return _物品属性_追加剑客移花接木;
			}
			set
			{
				_物品属性_追加剑客移花接木 = value;
			}
		}

		public int 物品属性_追加剑客连环飞舞
		{
			get
			{
				return _物品属性_追加剑客连环飞舞;
			}
			set
			{
				_物品属性_追加剑客连环飞舞 = value;
			}
		}

		public int 物品属性_追加剑客长虹贯日
		{
			get
			{
				return _物品属性_追加剑客长虹贯日;
			}
			set
			{
				_物品属性_追加剑客长虹贯日 = value;
			}
		}

		public int 物品属性_追加医九天真气
		{
			get
			{
				return _物品属性_追加医九天真气;
			}
			set
			{
				_物品属性_追加医九天真气 = value;
			}
		}

		public int 物品属性_追加医体血倍增
		{
			get
			{
				return _物品属性_追加医体血倍增;
			}
			set
			{
				_物品属性_追加医体血倍增 = value;
			}
		}

		public int 物品属性_追加医吸星大法
		{
			get
			{
				return _物品属性_追加医吸星大法;
			}
			set
			{
				_物品属性_追加医吸星大法 = value;
			}
		}

		public int 物品属性_追加医天佑之气
		{
			get
			{
				return _物品属性_追加医天佑之气;
			}
			set
			{
				_物品属性_追加医天佑之气 = value;
			}
		}

		public int 物品属性_追加医太极心法
		{
			get
			{
				return _物品属性_追加医太极心法;
			}
			set
			{
				_物品属性_追加医太极心法 = value;
			}
		}

		public int 物品属性_追加医妙手回春
		{
			get
			{
				return _物品属性_追加医妙手回春;
			}
			set
			{
				_物品属性_追加医妙手回春 = value;
			}
		}

		public int 物品属性_追加医洗髓易经
		{
			get
			{
				return _物品属性_追加医洗髓易经;
			}
			set
			{
				_物品属性_追加医洗髓易经 = value;
			}
		}

		public int 物品属性_追加医神农仙术
		{
			get
			{
				return _物品属性_追加医神农仙术;
			}
			set
			{
				_物品属性_追加医神农仙术 = value;
			}
		}

		public int 物品属性_追加医运气行心
		{
			get
			{
				return _物品属性_追加医运气行心;
			}
			set
			{
				_物品属性_追加医运气行心 = value;
			}
		}

		public int 物品属性_追加医长功攻击
		{
			get
			{
				return _物品属性_追加医长功攻击;
			}
			set
			{
				_物品属性_追加医长功攻击 = value;
			}
		}

		public int 物品属性_追加弓凝神聚气
		{
			get
			{
				return _物品属性_追加弓凝神聚气;
			}
			set
			{
				_物品属性_追加弓凝神聚气 = value;
			}
		}

		public int 物品属性_追加弓心神凝聚
		{
			get
			{
				return _物品属性_追加弓心神凝聚;
			}
			set
			{
				_物品属性_追加弓心神凝聚 = value;
			}
		}

		public int 物品属性_追加弓必杀一击
		{
			get
			{
				return _物品属性_追加弓必杀一击;
			}
			set
			{
				_物品属性_追加弓必杀一击 = value;
			}
		}

		public int 物品属性_追加弓无明暗矢
		{
			get
			{
				return _物品属性_追加弓无明暗矢;
			}
			set
			{
				_物品属性_追加弓无明暗矢 = value;
			}
		}

		public int 物品属性_追加弓正本培元
		{
			get
			{
				return _物品属性_追加弓正本培元;
			}
			set
			{
				_物品属性_追加弓正本培元 = value;
			}
		}

		public int 物品属性_追加弓流星三矢
		{
			get
			{
				return _物品属性_追加弓流星三矢;
			}
			set
			{
				_物品属性_追加弓流星三矢 = value;
			}
		}

		public int 物品属性_追加弓狂风万破
		{
			get
			{
				return _物品属性_追加弓狂风万破;
			}
			set
			{
				_物品属性_追加弓狂风万破 = value;
			}
		}

		public int 物品属性_追加弓猎鹰之眼
		{
			get
			{
				return _物品属性_追加弓猎鹰之眼;
			}
			set
			{
				_物品属性_追加弓猎鹰之眼 = value;
			}
		}

		public int 物品属性_追加弓百步穿杨
		{
			get
			{
				return _物品属性_追加弓百步穿杨;
			}
			set
			{
				_物品属性_追加弓百步穿杨 = value;
			}
		}

		public int 物品属性_追加弓锐利之箭
		{
			get
			{
				return _物品属性_追加弓锐利之箭;
			}
			set
			{
				_物品属性_追加弓锐利之箭 = value;
			}
		}

		public int 物品属性_追加枪客乾坤挪移
		{
			get
			{
				return _物品属性_追加枪客乾坤挪移;
			}
			set
			{
				_物品属性_追加枪客乾坤挪移 = value;
			}
		}

		public int 物品属性_追加枪客必杀一击
		{
			get
			{
				return _物品属性_追加枪客必杀一击;
			}
			set
			{
				_物品属性_追加枪客必杀一击 = value;
			}
		}

		public int 物品属性_追加枪客横练太保
		{
			get
			{
				return _物品属性_追加枪客横练太保;
			}
			set
			{
				_物品属性_追加枪客横练太保 = value;
			}
		}

		public int 物品属性_追加枪客灵甲护身
		{
			get
			{
				return _物品属性_追加枪客灵甲护身;
			}
			set
			{
				_物品属性_追加枪客灵甲护身 = value;
			}
		}

		public int 物品属性_追加枪客狂神降世
		{
			get
			{
				return _物品属性_追加枪客狂神降世;
			}
			set
			{
				_物品属性_追加枪客狂神降世 = value;
			}
		}

		public int 物品属性_追加枪客狂风万破
		{
			get
			{
				return _物品属性_追加枪客狂风万破;
			}
			set
			{
				_物品属性_追加枪客狂风万破 = value;
			}
		}

		public int 物品属性_追加枪客转守为攻
		{
			get
			{
				return _物品属性_追加枪客转守为攻;
			}
			set
			{
				_物品属性_追加枪客转守为攻 = value;
			}
		}

		public int 物品属性_追加枪客运气疗伤
		{
			get
			{
				return _物品属性_追加枪客运气疗伤;
			}
			set
			{
				_物品属性_追加枪客运气疗伤 = value;
			}
		}

		public int 物品属性_追加枪客连环飞舞
		{
			get
			{
				return _物品属性_追加枪客连环飞舞;
			}
			set
			{
				_物品属性_追加枪客连环飞舞 = value;
			}
		}

		public int 物品属性_追加枪客金钟罩气
		{
			get
			{
				return _物品属性_追加枪客金钟罩气;
			}
			set
			{
				_物品属性_追加枪客金钟罩气 = value;
			}
		}

		public int FLD_RESIDE2
		{
			get
			{
				return _FLD_RESIDE2;
			}
			set
			{
				_FLD_RESIDE2 = value;
			}
		}

		public int FLD_LEVEL
		{
			get
			{
				return _FLD_LEVEL;
			}
			set
			{
				_FLD_LEVEL = value;
			}
		}

		public int FLD_MAGIC0
		{
			get
			{
				byte[] array = new byte[4];
				Buffer.BlockCopy(物品_byte, 16, array, 0, 4);
				return BitConverter.ToInt32(array, 0);
			}
			set
			{
				Buffer.BlockCopy(BitConverter.GetBytes(value), 0, 物品_byte, 16, 2);
			}
		}

		public int FLD_强化类型
		{
			get
			{
				int fLD_MAGIC = FLD_MAGIC0;
				if (fLD_MAGIC > 0)
				{
					string text = fLD_MAGIC.ToString();
					return int.Parse(text.Substring(text.Length - 8, 1));
				}
				return 0;
			}
		}

		public int FLD_强化数量
		{
			get
			{
				int fLD_MAGIC = FLD_MAGIC0;
				if (fLD_MAGIC > 0)
				{
					string text = fLD_MAGIC.ToString();
					return int.Parse(text.Substring(text.Length - 2, 2));
				}
				return 0;
			}
		}

		public int FLD_属性类型
		{
			get
			{
				int fLD_MAGIC = FLD_MAGIC0;
				if (fLD_MAGIC > 0)
				{
					if (fLD_MAGIC > 1000000000)
					{
						string text = fLD_MAGIC.ToString();
						return int.Parse(text.Substring(text.Length - 4, 1));
					}
					return 0;
				}
				return 0;
			}
		}

		public int FLD_属性数量
		{
			get
			{
				int fLD_MAGIC = FLD_MAGIC0;
				if (fLD_MAGIC > 0)
				{
					if (fLD_MAGIC > 1000000000)
					{
						string text = fLD_MAGIC.ToString();
						return int.Parse(text.Substring(text.Length - 3, 1));
					}
					return 0;
				}
				return 0;
			}
		}

		public int FLD_MAGIC1
		{
			get
			{
				byte[] array = new byte[4];
				Buffer.BlockCopy(物品_byte, 20, array, 0, 4);
				return BitConverter.ToInt32(array, 0);
			}
			set
			{
				Buffer.BlockCopy(BitConverter.GetBytes(value), 0, 物品_byte, 20, 2);
			}
		}

		public int FLD_MAGIC2
		{
			get
			{
				byte[] array = new byte[4];
				Buffer.BlockCopy(物品_byte, 24, array, 0, 4);
				return BitConverter.ToInt32(array, 0);
			}
			set
			{
				Buffer.BlockCopy(BitConverter.GetBytes(value), 0, 物品_byte, 24, 2);
			}
		}

		public int FLD_MAGIC3
		{
			get
			{
				byte[] array = new byte[4];
				Buffer.BlockCopy(物品_byte, 28, array, 0, 4);
				return BitConverter.ToInt32(array, 0);
			}
			set
			{
				Buffer.BlockCopy(BitConverter.GetBytes(value), 0, 物品_byte, 28, 2);
			}
		}

		public int FLD_MAGIC4
		{
			get
			{
				byte[] array = new byte[4];
				Buffer.BlockCopy(物品_byte, 32, array, 0, 4);
				return BitConverter.ToInt32(array, 0);
			}
			set
			{
				Buffer.BlockCopy(BitConverter.GetBytes(value), 0, 物品_byte, 32, 2);
			}
		}

		public byte[] GetByte()
		{
			发包类 发包类 = new 发包类();
			发包类.Write(Get物品全局ID);
			if (物品绑定)
			{
				发包类.Write4(Get物品ID + 20000);
			}
			else
			{
				发包类.Write4(Get物品ID);
			}
			发包类.Write4(Get物品数量);
			发包类.Write4(FLD_MAGIC0);
			发包类.Write4(FLD_MAGIC1);
			发包类.Write4(FLD_MAGIC2);
			发包类.Write4(FLD_MAGIC3);
			发包类.Write4(FLD_MAGIC4);
			return 发包类.ToArray3();
		}

		public 物品类()
		{
		}

		public 物品类(byte[] 物品_byte_)
		{
			物品_byte = 物品_byte_;
		}

		public 物品类(byte[] 物品_byte_, int 位置)
		{
			物品_byte = 物品_byte_;
			物品位置 = 位置;
		}

		public void Dispose()
		{
		}

		public string 得到物品string()
		{
			try
			{
				return Converter.ToString(物品_byte);
			}
			catch
			{
				return "";
			}
		}

		public int 得到物品单个重量()
		{
			try
			{
				if (World.Itme.TryGetValue(BitConverter.ToInt32(物品ID, 0), out ItmeClass value))
				{
					return value.FLD_WEIGHT;
				}
				return 0;
			}
			catch
			{
				return 0;
			}
		}

		public int 得到物品头型()
		{
			try
			{
				if (World.Itme.TryGetValue(BitConverter.ToInt32(物品ID, 0), out ItmeClass value))
				{
					return value.FLD_HEAD_WEAR;
				}
				return 0;
			}
			catch
			{
				return 0;
			}
		}

		public int 得到物品重量()
		{
			try
			{
				if (World.Itme.TryGetValue(BitConverter.ToInt32(物品ID, 0), out ItmeClass value))
				{
					return value.FLD_WEIGHT * BitConverter.ToInt32(物品数量, 0);
				}
				return 0;
			}
			catch
			{
				return 0;
			}
		}

		public byte[] 得到物品属性()
		{
			byte[] array = new byte[20];
			Buffer.BlockCopy(物品_byte, 16, array, 0, 20);
			return array;
		}

		public byte[] 得到全局ID()
		{
			byte[] array = new byte[8];
			Buffer.BlockCopy(物品_byte, 0, array, 0, 8);
			return array;
		}

		public byte[] 得到物品ID()
		{
			byte[] array = new byte[4];
			Buffer.BlockCopy(物品_byte, 8, array, 0, 4);
			return array;
		}

		public byte[] 得到物品数量()
		{
			byte[] array = new byte[4];
			Buffer.BlockCopy(物品_byte, 12, array, 0, 4);
			return array;
		}

		public void 设置物品数量(byte[] 数量)
		{
			if (BitConverter.ToInt32(数量, 0) > 9999)
			{
				Buffer.BlockCopy(BitConverter.GetBytes(9999), 0, 物品_byte, 12, 4);
			}
			else
			{
				Buffer.BlockCopy(数量, 0, 物品_byte, 12, 4);
			}
		}

		public int 得到物品类型()
		{
			byte[] value = 得到物品ID();
			int key = BitConverter.ToInt32(value, 0);
			ItmeClass itmeClass = World.Itme[key];
			return itmeClass.FLD_SIDE;
		}

		public int 得到物品位置类型()
		{
			byte[] value = 得到物品ID();
			if (World.Itme.TryGetValue(BitConverter.ToInt32(value, 0), out ItmeClass value2))
			{
				return value2.FLD_RESIDE2;
			}
			return 0;
		}

		public string 得到物品名称()
		{
			if (World.Itme.TryGetValue(BitConverter.ToInt32(物品ID, 0), out ItmeClass value))
			{
				return value.ItmeNAME;
			}
			return "";
		}

		private void 清空物品属性方法()
		{
			FLD_RESIDE2 = 0;
			物品属性阶段数 = 0;
			物品属性强类型 = 0;
			物品属性强 = 0;
			物品属性阶段类型 = 0;
			物品攻击力 = 0;
			物品攻击力MAX = 0;
			物品属性_攻击力增加 = 0;
			物品防御力 = 0;
			物品属性_防御力增加 = 0;
			物品属性_生命力增加 = 0;
			物品属性_内功力增加 = 0;
			物品属性_命中率增加 = 0;
			物品属性_回避率增加 = 0;
			物品属性_武功攻击力 = 0;
			物品属性_全部气功等级增加 = 0;
			物品属性_升级成功率 = 0;
			物品属性_追加伤害值 = 0;
			物品属性_武功防御力增加 = 0;
			物品属性_获得金钱增加 = 0;
			物品属性_死亡损失经验减少 = 0;
			物品属性_经验获得增加 = 0;
			物品属性_追加医长功攻击 = 0;
			物品属性_追加医运气行心 = 0;
			物品属性_追加医洗髓易经 = 0;
			物品属性_追加医吸星大法 = 0;
			物品属性_追加医天佑之气 = 0;
			物品属性_追加医体血倍增 = 0;
			物品属性_追加医太极心法 = 0;
			物品属性_追加医神农仙术 = 0;
			物品属性_追加医妙手回春 = 0;
			物品属性_追加医九天真气 = 0;
			物品属性_追加枪客转守为攻 = 0;
			物品属性_追加枪客运气疗伤 = 0;
			物品属性_追加枪客乾坤挪移 = 0;
			物品属性_追加枪客灵甲护身 = 0;
			物品属性_追加枪客连环飞舞 = 0;
			物品属性_追加枪客狂神降世 = 0;
			物品属性_追加枪客狂风万破 = 0;
			物品属性_追加枪客金钟罩气 = 0;
			物品属性_追加枪客横练太保 = 0;
			物品属性_追加枪客必杀一击 = 0;
			物品属性_追加剑客长虹贯日 = 0;
			物品属性_追加剑客移花接木 = 0;
			物品属性_追加剑客怒海狂澜 = 0;
			物品属性_追加剑客连环飞舞 = 0;
			物品属性_追加剑客狂风万破 = 0;
			物品属性_追加剑客回柳身法 = 0;
			物品属性_追加剑客护身罡气 = 0;
			物品属性_追加剑客冲冠一怒 = 0;
			物品属性_追加剑客必杀一击 = 0;
			物品属性_追加剑客百变神行 = 0;
			物品属性_追加弓正本培元 = 0;
			物品属性_追加弓心神凝聚 = 0;
			物品属性_追加弓无明暗矢 = 0;
			物品属性_追加弓锐利之箭 = 0;
			物品属性_追加弓凝神聚气 = 0;
			物品属性_追加弓流星三矢 = 0;
			物品属性_追加弓猎鹰之眼 = 0;
			物品属性_追加弓狂风万破 = 0;
			物品属性_追加弓必杀一击 = 0;
			物品属性_追加弓百步穿杨 = 0;
			物品属性_追加刀客真武绝击 = 0;
			物品属性_追加刀客稳如泰山 = 0;
			物品属性_追加刀客四两千斤 = 0;
			物品属性_追加刀客摄魂一击 = 0;
			物品属性_追加刀客连环飞舞 = 0;
			物品属性_追加刀客力劈华山 = 0;
			物品属性_追加刀客狂风万破 = 0;
			物品属性_追加刀客必杀一击 = 0;
			物品属性_追加刀客霸气破甲 = 0;
			物品属性_追加刀客暗影绝杀 = 0;
		}

		public void 得到物品属性方法()
		{
			try
			{
				清空物品属性方法();
				if (BitConverter.ToInt32(物品ID, 0) != 0)
				{
					得到物品基本攻击力();
					byte[] array = new byte[4];
					Buffer.BlockCopy(物品_byte, 16, array, 0, 4);
					得到强化(BitConverter.ToInt32(array, 0).ToString());
					for (int i = 0; i < 4; i++)
					{
						byte[] array2 = new byte[4];
						Buffer.BlockCopy(物品_byte, 20 + i * 4, array2, 0, 4);
						得到基本属性(BitConverter.ToInt32(array2, 0).ToString());
					}
				}
			}
			catch (Exception ex)
			{
				Form1.WriteLine(1, "得到物品属性方法 出错：" + ex?.ToString());
			}
		}

		private int 得到基本属性控制(int 类型, int 数量)
		{
			foreach (石头属性调整类 value in World.石头属性调整.Values)
			{
				if (value.类型 == 类型 && value.数量 == 数量)
				{
					return value.加减;
				}
			}
			return 0;
		}

		public void 得到物品基本攻击力()
		{
			try
			{
				if (BitConverter.ToInt32(物品ID, 0) != 0)
				{
					ItmeClass itmeClass = World.Itme[BitConverter.ToInt32(物品ID, 0)];
					FLD_LEVEL = itmeClass.FLD_LEVEL;
					FLD_RESIDE2 = itmeClass.FLD_RESIDE2;
					物品攻击力 = itmeClass.FLD_AT;
					物品攻击力MAX = itmeClass.FLD_AT_Max;
					物品防御力 = itmeClass.FLD_DF;
				}
			}
			catch (Exception ex)
			{
				Form1.WriteLine(1, "得到物品基本攻击力 出错：" + ex?.ToString());
			}
		}

		private void 得到基本属性(string ysqh)
		{
			try
			{
				string text;
				switch (ysqh.Length)
				{
				default:
					return;
				case 8:
					text = ysqh.Substring(0, 1);
					break;
				case 9:
					text = ysqh.Substring(0, 2);
					break;
				}
				int num = (!(text == "8")) ? (int.Parse(ysqh) - int.Parse(text) * 10000000) : int.Parse(ysqh.Substring(ysqh.Length - 2, 2));
				num += 得到基本属性控制(int.Parse(text), num);
				switch (int.Parse(text))
				{
				case 1:
					物品属性_攻击力增加 += num;
					物品攻击力 += num;
					物品攻击力MAX += num;
					break;
				case 2:
					物品属性_防御力增加 += num;
					物品防御力 += num;
					break;
				case 3:
					物品属性_生命力增加 += num;
					break;
				case 4:
					物品属性_内功力增加 += num;
					break;
				case 5:
					物品属性_命中率增加 += num;
					break;
				case 6:
					物品属性_回避率增加 += num;
					break;
				case 7:
					switch (num)
					{
					case 20:
						物品属性_武功攻击力 += num + int.Parse(World.武功攻击额外调整[0]);
						break;
					case 21:
						物品属性_武功攻击力 += num + int.Parse(World.武功攻击额外调整[1]);
						break;
					case 22:
						物品属性_武功攻击力 += num + int.Parse(World.武功攻击额外调整[2]);
						break;
					case 23:
						物品属性_武功攻击力 += num + int.Parse(World.武功攻击额外调整[3]);
						break;
					case 24:
						物品属性_武功攻击力 += num + int.Parse(World.武功攻击额外调整[4]);
						break;
					case 25:
						物品属性_武功攻击力 += num + int.Parse(World.武功攻击额外调整[5]);
						break;
					case 26:
						物品属性_武功攻击力 += num + int.Parse(World.武功攻击额外调整[6]);
						break;
					case 27:
						物品属性_武功攻击力 += num + int.Parse(World.武功攻击额外调整[7]);
						break;
					case 28:
						物品属性_武功攻击力 += num + int.Parse(World.武功攻击额外调整[8]);
						break;
					case 29:
						物品属性_武功攻击力 += num + int.Parse(World.武功攻击额外调整[9]);
						break;
					case 30:
						物品属性_武功攻击力 += num + int.Parse(World.武功攻击额外调整[10]);
						break;
					case 31:
						物品属性_武功攻击力 += num + int.Parse(World.武功攻击额外调整[11]);
						break;
					case 32:
						物品属性_武功攻击力 += num + int.Parse(World.武功攻击额外调整[12]);
						break;
					case 34:
						物品属性_武功攻击力 += num + int.Parse(World.武功攻击额外调整[13]);
						break;
					case 36:
						物品属性_武功攻击力 += num + int.Parse(World.武功攻击额外调整[14]);
						break;
					case 38:
						物品属性_武功攻击力 += num + int.Parse(World.武功攻击额外调整[15]);
						break;
					case 40:
						物品属性_武功攻击力 += num + int.Parse(World.武功攻击额外调整[16]);
						break;
					default:
						物品属性_武功攻击力 += num;
						break;
					}
					break;
				case 8:
				{
					string text2 = ysqh.Substring(4, 2);
					if (text2 != null)
					{
						switch (text2)
						{
						case "00":
							物品属性_全部气功等级增加 += num;
							break;
						case "10":
							物品属性_追加刀客力劈华山 += num;
							break;
						case "11":
							物品属性_追加刀客摄魂一击 += num;
							break;
						case "15":
							物品属性_追加刀客四两千斤 += num;
							break;
						case "16":
							物品属性_追加刀客霸气破甲 += num;
							break;
						case "17":
							物品属性_追加刀客真武绝击 += num;
							break;
						case "18":
							物品属性_追加刀客暗影绝杀 += num;
							break;
						case "19":
							物品属性_追加刀客稳如泰山 += num;
							break;
						case "20":
							物品属性_追加剑客长虹贯日 += num;
							break;
						case "21":
							物品属性_追加剑客百变神行 += num;
							break;
						case "25":
							物品属性_追加剑客护身罡气 += num;
							break;
						case "26":
							物品属性_追加剑客移花接木 += num;
							break;
						case "27":
							物品属性_追加剑客回柳身法 += num;
							break;
						case "28":
							物品属性_追加剑客怒海狂澜 += num;
							break;
						case "29":
							物品属性_追加剑客冲冠一怒 += num;
							break;
						case "30":
							物品属性_追加枪客金钟罩气 += num;
							break;
						case "31":
							物品属性_追加枪客运气疗伤 += num;
							break;
						case "35":
							物品属性_追加枪客横练太保 += num;
							break;
						case "36":
							物品属性_追加枪客乾坤挪移 += num;
							break;
						case "37":
							物品属性_追加枪客灵甲护身 += num;
							break;
						case "38":
							物品属性_追加枪客狂神降世 += num;
							break;
						case "39":
							物品属性_追加枪客转守为攻 += num;
							break;
						case "40":
							物品属性_追加弓百步穿杨 += num;
							break;
						case "41":
							物品属性_追加弓猎鹰之眼 += num;
							break;
						case "42":
							物品属性_追加弓凝神聚气 += num;
							break;
						case "45":
							物品属性_追加弓正本培元 += num;
							break;
						case "46":
							物品属性_追加弓心神凝聚 += num;
							break;
						case "47":
							物品属性_追加弓流星三矢 += num;
							break;
						case "48":
							物品属性_追加弓锐利之箭 += num;
							break;
						case "49":
							物品属性_追加弓无明暗矢 += num;
							break;
						case "50":
							物品属性_追加医运气行心 += num;
							break;
						case "51":
							物品属性_追加医太极心法 += num;
							break;
						case "52":
							物品属性_追加医体血倍增 += num;
							break;
						case "53":
							物品属性_追加医洗髓易经 += num;
							break;
						case "54":
							物品属性_追加医妙手回春 += num;
							break;
						case "55":
							物品属性_追加医长功攻击 += num;
							break;
						case "56":
							物品属性_追加医吸星大法 += num;
							break;
						case "57":
							物品属性_追加医神农仙术 += num;
							break;
						case "58":
							物品属性_追加医天佑之气 += num;
							break;
						case "59":
							物品属性_追加医九天真气 += num;
							break;
						case "32":
						case "12":
						case "22":
							物品属性_追加刀客连环飞舞 += num;
							物品属性_追加剑客连环飞舞 += num;
							物品属性_追加枪客连环飞舞 += num;
							break;
						case "33":
						case "43":
						case "13":
						case "23":
							物品属性_追加刀客必杀一击 += num;
							物品属性_追加剑客必杀一击 += num;
							物品属性_追加枪客必杀一击 += num;
							物品属性_追加弓必杀一击 += num;
							break;
						case "44":
						case "34":
						case "14":
						case "24":
							物品属性_追加刀客狂风万破 += num;
							物品属性_追加剑客狂风万破 += num;
							物品属性_追加枪客狂风万破 += num;
							物品属性_追加弓狂风万破 += num;
							break;
						}
					}
					break;
				}
				case 9:
					物品属性_升级成功率 += num;
					break;
				case 10:
					物品属性_追加伤害值 += num;
					break;
				case 11:
					switch (num)
					{
					case 34:
						物品属性_武功防御力增加 += num + int.Parse(World.武功防额外调整[0]);
						break;
					case 36:
						物品属性_武功防御力增加 += num + int.Parse(World.武功防额外调整[1]);
						break;
					case 38:
						物品属性_武功防御力增加 += num + int.Parse(World.武功防额外调整[2]);
						break;
					case 40:
						物品属性_武功防御力增加 += num + int.Parse(World.武功防额外调整[3]);
						break;
					case 74:
						物品属性_武功防御力增加 += num + int.Parse(World.武功防额外调整[4]);
						break;
					case 76:
						物品属性_武功防御力增加 += num + int.Parse(World.武功防额外调整[5]);
						break;
					case 78:
						物品属性_武功防御力增加 += num + int.Parse(World.武功防额外调整[6]);
						break;
					case 80:
						物品属性_武功防御力增加 += num + int.Parse(World.武功防额外调整[7]);
						break;
					case 84:
						物品属性_武功防御力增加 += num + int.Parse(World.武功防额外调整[8]);
						break;
					case 88:
						物品属性_武功防御力增加 += num + int.Parse(World.武功防额外调整[9]);
						break;
					case 92:
						物品属性_武功防御力增加 += num + int.Parse(World.武功防额外调整[10]);
						break;
					case 96:
						物品属性_武功防御力增加 += num + int.Parse(World.武功防额外调整[11]);
						break;
					case 98:
						物品属性_武功防御力增加 += num + int.Parse(World.武功防额外调整[12]);
						break;
					case 100:
						物品属性_武功防御力增加 += num + int.Parse(World.武功防额外调整[13]);
						break;
					default:
						物品属性_武功防御力增加 += num;
						break;
					}
					break;
				case 12:
					物品属性_获得金钱增加 += num;
					break;
				case 13:
					物品属性_死亡损失经验减少 += num;
					break;
				case 14:
					物品属性_经验获得增加 += num;
					break;
				case 15:
					物品属性_经验获得增加 += num;
					break;
				}
			}
			catch (Exception ex)
			{
				Form1.WriteLine(1, "得到基本属性 出错：" + ex?.ToString());
			}
		}

		private void 得到强化(string ysqh)
		{
			try
			{
				switch (ysqh.Length)
				{
				case 9:
					break;
				case 8:
					物品属性强类型 = int.Parse(ysqh.Substring(ysqh.Length - 8, 1));
					物品属性强 = int.Parse(ysqh.Substring(ysqh.Length - 3, 3));
					if (物品属性强类型 == 1)
					{
						物品攻击力 += 物品属性强 * 6;
						物品攻击力MAX += 物品属性强 * 6;
					}
					else if (物品属性强类型 == 2)
					{
						物品防御力 += 物品属性强 * 3;
					}
					break;
				case 10:
					物品属性阶段类型 = int.Parse(ysqh.Substring(ysqh.Length - 4, 1));
					物品属性阶段数 = int.Parse(ysqh.Substring(ysqh.Length - 3, 1)) + 1;
					物品属性强类型 = int.Parse(ysqh.Substring(ysqh.Length - 8, 1));
					物品属性强 = int.Parse(ysqh.Substring(ysqh.Length - 2, 2));
					if (物品属性强类型 == 1)
					{
						物品攻击力 += 物品属性强 * 6;
						物品攻击力MAX += 物品属性强 * 6;
					}
					else if (物品属性强类型 == 2)
					{
						物品防御力 += 物品属性强 * 3;
					}
					else if (物品属性强类型 == 3)
					{
						物品属性_生命力增加 += 物品属性强 * 15;
						物品属性_武功防御力增加 += 物品属性强;
					}
					else if (物品属性强类型 == 4)
					{
						物品攻击力 += 物品属性强 * 10;
						物品攻击力MAX += 物品属性强 * 10;
						物品防御力 += 物品属性强 * 10;
						物品属性_武功攻击力 += 物品属性强 * 5;
					}
					else if (物品属性强类型 == 5)
					{
						物品攻击力 += 物品属性强 * 10;
						物品攻击力MAX += 物品属性强 * 10;
						物品属性_生命力增加 += 物品属性强 * 10;
					}
					break;
				}
			}
			catch (Exception ex)
			{
				Form1.WriteLine(1, "得到强化 出错：" + ex?.ToString());
			}
		}
	}
}
